/*
 * StorageResourceFactory.cpp
 *
 *  Created on: 03/10/2009
 *      Author: nik0l4z
 */

#include "StorageResourceFactory.h"
#include "Strategies/Storage/TextStorageStrategy.h"
#include "Strategies/Index/ExtensibleHashIndexStratregy.h"
#include "Strategies/Resource/SimpleResourceStrategy.h"
#include "Strategies/Resource/DirectResourceStrategy.h"
#include "Strategies/Index/BSharpIndexStrategy.h"
#include "Strategies/Index/SecIndex.h"
#include "Strategies/Resource/DeferredResourceStrategy.h"
#include "Strategies/Storage/RecordStorageStrategy.h"


/*  Cuando se crea la factory inmediatamente se crea un recurso.Luego a este, depenediendo de que metodo de la factory se invoque
 *  se le setearán las distintas estrategias.
 */
StorageResourceFactory::StorageResourceFactory() {

}

StorageResourceFactory::~StorageResourceFactory() {
	cout << "Se elimina Fabrica de recurso de Almacenamiento " << endl;
    delete storageResource;
}

void StorageResourceFactory::setStorageResource(StorageResource *storageResource){
    this->storageResource = storageResource;
}

StorageResource* StorageResourceFactory::getStorageResource() const {
    return storageResource;
}

/*------------------------------------Text Resource Storage Implementation------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------*/

void StorageResourceFactory::createStorageTextResource(string nombreArchivo){

	StorageResource *storageResource = new StorageResource();
	this->setStorageResource(storageResource);

	this->getStorageResource()->setStorageStrategy(new TextStorageStrategy());
     /*-------------Comportamiento Default----------------------------------------*/
	this->getStorageResource()->setIndexStategy(new SecIndex());
//	this->getStorageResource()->setIndexStategy(new BSharpIndexStrategy("ahhhh.txt",tamanioNodo));
    this->getStorageResource()->setResourceStrategy(new SimpleResourceStrategy());
    this->getStorageResource()->getStorageStrategy()->setStorage(new ArchivoTexto(nombreArchivo));
    this->getStorageResource()->getStorageStrategy()->setResourceStrategy(this->getStorageResource()->getResourceStrategy());
    this->getStorageResource()->getResourceStrategy()->setStorage(this->getStorageResource()->getStorageStrategy()->getStorage());
    string nombreArchivoIndice;
    nombreArchivoIndice = "IndiceSec" + nombreArchivo;
    this->getStorageResource()->getIndexStategy()->setStorage(new ArchivoTexto(nombreArchivoIndice));

     /*--------------------------------------------------------------------------*/
}
void StorageResourceFactory::createStorageTextResourceInFileSingleWriting(string *path,Clave clave, string nombreArchivo, unsigned short tamanioNodo){
	StorageResource *storageResource = new StorageResource();
	this->setStorageResource(storageResource);

	this->getStorageResource()->setStorageStrategy(new TextStorageStrategy());
	 this->getStorageResource()->setResourceStrategy(new SimpleResourceStrategy());
	 this->getStorageResource()->getStorageStrategy()->setStorage(new Archivo());
     /*-------------Comportamiento Default----------------------------------------*/
	 this->getStorageResource()->setIndexStategy(new SecIndex());
	 /*--------------------------------------------------------------------------*/
}

void StorageResourceFactory::createStorageTextResourceDeferredWriting(string nombreArchivo, unsigned short tamanioNodo){
	StorageResource *storageResource = new StorageResource();
	this->setStorageResource(storageResource);

	this->getStorageResource()->setStorageStrategy(new TextStorageStrategy());
	this->getStorageResource()->setIndexStategy(new SecIndex());
	this->getStorageResource()->setResourceStrategy(new DeferredResourceStrategy());
	this->getStorageResource()->getStorageStrategy()->setStorage(new Buffer());
}


void StorageResourceFactory::createStorageTextResourceInFileDeferredWriting(string *path,Clave clave, string nombreArchivo, unsigned short tamanioNodo){
	StorageResource *storageResource = new StorageResource();
	this->setStorageResource(storageResource);

	this->getStorageResource()->setStorageStrategy(new TextStorageStrategy());
	this->getStorageResource()->setResourceStrategy(new DeferredResourceStrategy());
	this->getStorageResource()->getStorageStrategy()->setStorage(new Archivo());
	/*-----------Comoportamiento default----------------------------------------*/
	this->getStorageResource()->setIndexStategy(new SecIndex());
	/*--------------------------------------------------------------------------*/
}


void StorageResourceFactory::createStorageTextResourceInBuffer(string nombreArchivo, unsigned short tamanioNodo){
	StorageResource *storageResource = new StorageResource();
	this->setStorageResource(storageResource);

	this->getStorageResource()->setStorageStrategy(new TextStorageStrategy());
	this->getStorageResource()->getStorageStrategy()->setStorage(new Buffer());
	/*-----------Comoportamiento default----------------------------------------*/
	this->getStorageResource()->setIndexStategy(new SecIndex());
	this->getStorageResource()->setResourceStrategy(new SimpleResourceStrategy());
	/*--------------------------------------------------------------------------*/
}


void StorageResourceFactory::createStorageTextResourceInFile(string *path,Clave clave){
	StorageResource *storageResource = new StorageResource();
	this->setStorageResource(storageResource);

	this->getStorageResource()->setStorageStrategy(new TextStorageStrategy());
	this->getStorageResource()->getStorageStrategy()->setStorage(new ArchivoTexto(*path));
	/*-----------Comoportamiento default----------------------------------------*/
	this->getStorageResource()->setResourceStrategy(new SimpleResourceStrategy());
	this->getStorageResource()->setIndexStategy(new ExtensibleHashIndexStratregy());
	/*--------------------------------------------------------------------------*/
}

void StorageResourceFactory::createStorageTextResourceSingleWriting(string nombreArchivo, unsigned short tamanioNodo){
	StorageResource *storageResource = new StorageResource();
	this->setStorageResource(storageResource);

	this->getStorageResource()->setStorageStrategy(new TextStorageStrategy());
	this->getStorageResource()->setResourceStrategy(new SimpleResourceStrategy());
	/*-----------Comoportamiento default----------------------------------------*/
	this->getStorageResource()->setIndexStategy(new SecIndex());
	this->getStorageResource()->getStorageStrategy()->setStorage(new Buffer());
	/*--------------------------------------------------------------------------*/
}

void StorageResourceFactory::createStorageTextResourceInBufferIndexedByBsharp(string nombreArchivo, unsigned short tamanioNodo){
	StorageResource *storageResource = new StorageResource();
	this->setStorageResource(storageResource);

	this->getStorageResource()->setStorageStrategy(new TextStorageStrategy());
	this->getStorageResource()->setIndexStategy(new SecIndex());
	this->getStorageResource()->getStorageStrategy()->setStorage(new Buffer());
	/*-----------Comoportamiento default----------------------------------------*/
	this->getStorageResource()->setResourceStrategy(new SimpleResourceStrategy());
	/*--------------------------------------------------------------------------*/
}



void StorageResourceFactory::createStorageTextResourceInFileIndexedByBsharp(string *path,Clave clave, string nombreArchivo, unsigned short tamanioNodo){
	StorageResource *storageResource = new StorageResource();
	this->setStorageResource(storageResource);

	this->getStorageResource()->setStorageStrategy(new TextStorageStrategy());
	this->getStorageResource()->setIndexStategy(new SecIndex());
	this->getStorageResource()->getStorageStrategy()->setStorage(new ArchivoTexto(*path));
	/*-----------Comoportamiento default----------------------------------------*/
	this->getStorageResource()->setResourceStrategy(new SimpleResourceStrategy());
	/*--------------------------------------------------------------------------*/
}


void StorageResourceFactory::createStorageTextResourceInBufferSingleWriting(string nombreArchivo, unsigned short tamanioNodo){
	StorageResource *storageResource = new StorageResource();
	this->setStorageResource(storageResource);

	this->getStorageResource()->setStorageStrategy(new TextStorageStrategy());
	this->getStorageResource()->getStorageStrategy()->setStorage(new Buffer());
	this->getStorageResource()->setResourceStrategy(new SimpleResourceStrategy());
	/*-----------Comoportamiento default----------------------------------------*/
	this->getStorageResource()->setIndexStategy(new SecIndex());
	/*--------------------------------------------------------------------------*/
}

void StorageResourceFactory::createStorageTextResourceInBufferDeferredWriting(string nombreArchivo, unsigned short tamanioNodo){
	StorageResource *storageResource = new StorageResource();
	this->setStorageResource(storageResource);

	this->getStorageResource()->setStorageStrategy(new TextStorageStrategy());
	this->getStorageResource()->getStorageStrategy()->setStorage(new Buffer());
	this->getStorageResource()->setResourceStrategy(new DeferredResourceStrategy());
	/*-----------Comoportamiento default----------------------------------------*/
	this->getStorageResource()->setIndexStategy(new SecIndex());
	/*----------------------------------------------------------------------*/
}

// -----------------CREACION DE RECURSOS CON ESTATEGIA DE ALMACENAMIENTO EN BLOQUES-----------------------------------------------

void StorageResourceFactory::createStorageBlockResource(int tamaniobloque, const string& nombreArchivo) {
	StorageResource *storageResource = new StorageResource();
	this->setStorageResource(storageResource);
	this->getStorageResource()->setStorageStrategy(new BlockStorageStrategy(nombreArchivo,tamaniobloque));

	// ------------- Comportamiento por default ------------------------------

	this->getStorageResource()->setResourceStrategy(new SimpleResourceStrategy());

	// Estrategia de Almacenamiento tiene una instancia de Archivo Binario
	this->getStorageResource()->getStorageStrategy()->setStorage(new ArchivoBinario(nombreArchivo,tamaniobloque));

	//	Estrategia Recurso tiene un puntero a la instancia de Almacenamiento definida en Estrategia de Almacenamiento
	this->getStorageResource()->getResourceStrategy()->setStorage(this->getStorageResource()->getStorageStrategy()->getStorage());


	//	Estrategia de Almacenamiento tiene un puntero a la instancia de Estrategia Recurso incluida en el Recurso
	this->getStorageResource()->getStorageStrategy()->setResourceStrategy(this->getStorageResource()->getResourceStrategy());

	//	Se instancia el Indice Hash. Se le pasa por parametro un puntero a la instancia de la estrategia de Almacenamiento incluida en el Recurso
	this->getStorageResource()->setIndexStategy(new ExtensibleHashIndexStratregy(tamaniobloque,nombreArchivo,this->getStorageResource()->getStorageStrategy()));
}



void StorageResourceFactory::createStorageBlockResourceInBuffer(int tamaniobloque, const string& nombreArchivo){

	StorageResource *storageResource = new StorageResource();

	this->setStorageResource(storageResource);

	this->getStorageResource()->setStorageStrategy(new BlockStorageStrategy(nombreArchivo,tamaniobloque));
	// ------------- Comportamiento por default ------------------------------

	this->getStorageResource()->setResourceStrategy(new DirectResourceStrategy( new Buffer(), new ArchivoBinario(nombreArchivo,tamaniobloque)));

	//	Estrategia de Almacenamiento tiene un puntero a la instancia de Estrategia Recurso incluida en el Recurso
	this->getStorageResource()->getStorageStrategy()->setResourceStrategy(this->getStorageResource()->getResourceStrategy());

	//	Se instancia el Indice Hash. Se le pasa por parametro un puntero a la instancia de la estrategia de Almacenamiento incluida en el Recurso
	this->getStorageResource()->setIndexStategy(new ExtensibleHashIndexStratregy(tamaniobloque,nombreArchivo,this->getStorageResource()->getStorageStrategy()));

}

void StorageResourceFactory::createStorageBlockResourceInFile(int tamaniobloque, const string& nombreArchivo)
{

	StorageResource *storageResource = new StorageResource();
	this->setStorageResource(storageResource);
	this->getStorageResource()->setStorageStrategy(new BlockStorageStrategy(nombreArchivo,tamaniobloque));
	// ------------- Comportamiento por default ------------------------------
	this->getStorageResource()->setResourceStrategy(new SimpleResourceStrategy());
	// Estrategia de Almacenamiento tiene una instancia de Archivo Binario
	this->getStorageResource()->getStorageStrategy()->setStorage(new ArchivoBinario(nombreArchivo,tamaniobloque));

	//	Estrategia Recurso tiene un puntero a la instancia de Almacenamiento definida en Estrategia de Almacenamiento
	this->getStorageResource()->getResourceStrategy()->setStorage(this->getStorageResource()->getStorageStrategy()->getStorage());

	//	Estrategia de Almacenamiento tiene un puntero a la instancia de Estrategia Recurso incluida en el Recurso
	this->getStorageResource()->getStorageStrategy()->setResourceStrategy(this->getStorageResource()->getResourceStrategy());

	//	Se instancia el Indice Hash. Se le pasa por parametro un puntero a la instancia de la estrategia de Almacenamiento incluida en el Recurso
	//this->getStorageResource()->setIndexStategy(new ExtensibleHashIndexStratregy(tamaniobloque,nombreArchivo,this->getStorageResource()->getStorageStrategy()));
	this->getStorageResource()->setIndexStategy(new SecIndex());
	string nombreArchivoIndice;

	nombreArchivoIndice = "IndiceSec" + nombreArchivo;

	this->getStorageResource()->getIndexStategy()->setStorage(new ArchivoTexto(nombreArchivoIndice));

}


void StorageResourceFactory::createStorageBlockResourceInBufferIndexedByExtensibleHash(int tamaniobloque, const string& nombreArchivo){

	StorageResource *storageResource = new StorageResource();
	this->setStorageResource(storageResource);

	this->getStorageResource()->setStorageStrategy(new BlockStorageStrategy(nombreArchivo,tamaniobloque));
	// ------------- Comportamiento por default ------------------------------
	this->getStorageResource()->setResourceStrategy(new DirectResourceStrategy( new Buffer(), new ArchivoBinario(nombreArchivo,tamaniobloque)));

	//	Estrategia de Almacenamiento tiene un puntero a la instancia de Estrategia Recurso incluida en el Recurso
	this->getStorageResource()->getStorageStrategy()->setResourceStrategy(this->getStorageResource()->getResourceStrategy());


	//	Se instancia el Indice Hash. Se le pasa por parametro un puntero a la instancia de la estrategia de Almacenamiento incluida en el Recurso
	this->getStorageResource()->setIndexStategy(new ExtensibleHashIndexStratregy(tamaniobloque,nombreArchivo,this->getStorageResource()->getStorageStrategy()));


}



void StorageResourceFactory:: createStorageBlockResourceInFileIndexedByExtensibleHash(int tamaniobloque, const string& nombreArchivo){
	StorageResource *storageResource = new StorageResource();
	this->setStorageResource(storageResource);

	this->getStorageResource()->setStorageStrategy(new BlockStorageStrategy(nombreArchivo,tamaniobloque));

	this->getStorageResource()->setResourceStrategy(new SimpleResourceStrategy());

	// Estrategia de Almacenamiento tiene una instancia de Archivo Binario
	this->getStorageResource()->getStorageStrategy()->setStorage(new ArchivoBinario(nombreArchivo,tamaniobloque));

	//	Estrategia Recurso tiene un puntero a la instancia de Almacenamiento definida en Estrategia de Almacenamiento
	this->getStorageResource()->getResourceStrategy()->setStorage(this->getStorageResource()->getStorageStrategy()->getStorage());

	//	Estrategia de Almacenamiento tiene un puntero a la instancia de Estrategia Recurso incluida en el Recurso
	this->getStorageResource()->getStorageStrategy()->setResourceStrategy(this->getStorageResource()->getResourceStrategy());

	//	Se instancia el Indice Hash. Se le pasa por parametro un puntero a la instancia de la estrategia de Almacenamiento incluida en el Recurso
	this->getStorageResource()->setIndexStategy(new ExtensibleHashIndexStratregy(tamaniobloque,nombreArchivo,this->getStorageResource()->getStorageStrategy()));

}



void StorageResourceFactory::createStorageBlockResourceIndexedByExtensibleHashSingleWriting(int tamaniobloque, const string& nombreArchivo){

	StorageResource *storageResource = new StorageResource();
	this->setStorageResource(storageResource);

	this->getStorageResource()->setStorageStrategy(new BlockStorageStrategy(nombreArchivo,tamaniobloque));

	this->getStorageResource()->setResourceStrategy(new SimpleResourceStrategy());

	// Estrategia de Almacenamiento tiene una instancia de Archivo Binario
	this->getStorageResource()->getStorageStrategy()->setStorage(new ArchivoBinario(nombreArchivo,tamaniobloque));

	//	Estrategia Recurso tiene un puntero a la instancia de Almacenamiento definida en Estrategia de Almacenamiento
	this->getStorageResource()->getResourceStrategy()->setStorage(this->getStorageResource()->getStorageStrategy()->getStorage());

	//	Estrategia de Almacenamiento tiene un puntero a la instancia de Estrategia Recurso incluida en el Recurso
	this->getStorageResource()->getStorageStrategy()->setResourceStrategy(this->getStorageResource()->getResourceStrategy());

	//	Se instancia el Indice Hash. Se le pasa por parametro un puntero a la instancia de la estrategia de Almacenamiento incluida en el Recurso
	this->getStorageResource()->setIndexStategy(new ExtensibleHashIndexStratregy(tamaniobloque,nombreArchivo,this->getStorageResource()->getStorageStrategy()));


}


void StorageResourceFactory::createStorageBlockResourceIndexedByExtensibleHashDeferredWriting(int tamaniobloque, const string& nombreArchivo){


	StorageResource *storageResource = new StorageResource();
	this->setStorageResource(storageResource);

	this->getStorageResource()->setStorageStrategy(new BlockStorageStrategy(nombreArchivo,tamaniobloque));

	this->getStorageResource()->setResourceStrategy(new DeferredResourceStrategy( new Buffer(), new ArchivoBinario(nombreArchivo,tamaniobloque)));

	//	Estrategia de Almacenamiento tiene un puntero a la instancia de Estrategia Recurso incluida en el Recurso
	this->getStorageResource()->getStorageStrategy()->setResourceStrategy(this->getStorageResource()->getResourceStrategy());


	//	Se instancia el Indice Hash. Se le pasa por parametro un puntero a la instancia de la estrategia de Almacenamiento incluida en el Recurso
	this->getStorageResource()->setIndexStategy(new ExtensibleHashIndexStratregy(tamaniobloque,nombreArchivo,this->getStorageResource()->getStorageStrategy()));

}


void StorageResourceFactory::createStorageBlockResourceInFileIndexedByExtensibleHashSingleWriting(int tamaniobloque, const string& nombreArchivo){

	StorageResource *storageResource = new StorageResource();
	this->setStorageResource(storageResource);

	this->getStorageResource()->setStorageStrategy(new BlockStorageStrategy(nombreArchivo,tamaniobloque));

	this->getStorageResource()->setResourceStrategy(new SimpleResourceStrategy());

	// Estrategia de Almacenamiento tiene una instancia de Archivo Binario
	this->getStorageResource()->getStorageStrategy()->setStorage(new ArchivoBinario(nombreArchivo,tamaniobloque));

	//	Estrategia Recurso tiene un puntero a la instancia de Almacenamiento definida en Estrategia de Almacenamiento
	this->getStorageResource()->getResourceStrategy()->setStorage(this->getStorageResource()->getStorageStrategy()->getStorage());

	//	Estrategia de Almacenamiento tiene un puntero a la instancia de Estrategia Recurso incluida en el Recurso
	this->getStorageResource()->getStorageStrategy()->setResourceStrategy(this->getStorageResource()->getResourceStrategy());

	//	Se instancia el Indice Hash. Se le pasa por parametro un puntero a la instancia de la estrategia de Almacenamiento incluida en el Recurso
	this->getStorageResource()->setIndexStategy(new ExtensibleHashIndexStratregy(tamaniobloque,nombreArchivo,this->getStorageResource()->getStorageStrategy()));

}

void StorageResourceFactory::createStorageRecordResource(int tamanioRegistro, string nombreArchivo){

	StorageResource *storageResource = new StorageResource();
	this->setStorageResource(storageResource);

	this->getStorageResource()->setStorageStrategy(new RecordStorageStrategy(tamanioRegistro,nombreArchivo));

	this->getStorageResource()->setResourceStrategy(new SimpleResourceStrategy());

	// Estrategia de Almacenamiento tiene una instancia de Archivo Binario
	this->getStorageResource()->getStorageStrategy()->setStorage(new ArchivoBinario(nombreArchivo,tamanioRegistro));

	//	Estrategia Recurso tiene un puntero a la instancia de Almacenamiento definida en Estrategia de Almacenamiento
	this->getStorageResource()->getResourceStrategy()->setStorage(this->getStorageResource()->getStorageStrategy()->getStorage());

	//	Estrategia de Almacenamiento tiene un puntero a la instancia de Estrategia Recurso incluida en el Recurso
	this->getStorageResource()->getStorageStrategy()->setResourceStrategy(this->getStorageResource()->getResourceStrategy());

	//	Se instancia el Indice Hash. Se le pasa por parametro un puntero a la instancia de la estrategia de Almacenamiento incluida en el Recurso
	this->getStorageResource()->setIndexStategy(new SecIndex());

	string nombreArchivoIndice;

	nombreArchivoIndice = "IndiceSec" + nombreArchivo;

	this->getStorageResource()->getIndexStategy()->setStorage(new ArchivoTexto(nombreArchivoIndice));

}


void StorageResourceFactory::setCompressMode(){

	this->getStorageResource()->setCompressMode(true);

}

/*------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------*/
